#ifndef SQLPARSER_SQLPARSER_H
#define SQLPARSER_SQLPARSER_H
#include "SQLParserResult.h"
#include "sql/statements.h"
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include <functional>

namespace ment {

    // 前向声明
    class SQLParserContext;
    class SQLParserFactory;
    class SQLErrorHandler;
    class SQLTokenizer;
    class SQLSyntaxAnalyzer;

    // SQL����������
    struct SQLParserConfig {
        bool enableDebugMode = false;
        bool strictMode = true;
        int maxErrorCount = 10;
        std::string encoding = "UTF-8";
    };

    // SQL�������ӿ�
    class ISQLParser {
    public:
        virtual ~ISQLParser() = default;
        virtual bool parse(const std::string& sql, SQLParserResult* result) = 0;
        virtual bool tokenize(const std::string& sql, std::vector<int16_t>* tokens) = 0;
    };

    // SQL���������Ĺ�����
    class SQLParserContext {
    public:
        SQLParserContext();
        ~SQLParserContext();

        void setConfig(const SQLParserConfig& config);
        const SQLParserConfig& getConfig() const;

        void reset();
        void addError(const std::string& error, int line = -1, int column = -1);
        const std::vector<std::string>& getErrors() const;

    private:
        SQLParserConfig config_;
        std::vector<std::string> errors_;
    };

    // SQL��������
    class SQLErrorHandler {
    public:
        SQLErrorHandler(SQLParserContext* context);

        void handleError(const std::string& message, int line = -1, int column = -1);
        void handleWarning(const std::string& message);
        bool hasErrors() const;
        void clearErrors();

    private:
        SQLParserContext* context_;
        bool hasErrors_;
    };

    // SQL�ʷ�������
    class SQLTokenizer {
    public:
        SQLTokenizer(SQLParserContext* context);

        bool tokenize(const std::string& sql, std::vector<int16_t>* tokens);

    private:
        SQLParserContext* context_;
        bool initializeLexer(const std::string& sql);
        void cleanupLexer();
    };

    // SQL�﷨������
    class SQLSyntaxAnalyzer {
    public:
        SQLSyntaxAnalyzer(SQLParserContext* context);

        bool analyze(const std::string& sql, SQLParserResult* result);

    private:
        SQLParserContext* context_;
        bool performSyntaxAnalysis(const std::string& sql, SQLParserResult* result);
    };

    // SQL����������
    class SQLParserFactory {
    public:
        static SQLParserFactory& getInstance();

        std::unique_ptr<ISQLParser> createParser(const SQLParserConfig& config = SQLParserConfig());
        void registerParserType(const std::string& type, std::function<std::unique_ptr<ISQLParser>()> factory);

    private:
        SQLParserFactory() = default;
        std::unordered_map<std::string, std::function<std::unique_ptr<ISQLParser>()>> factories_;
    };

    // Ĭ��SQL������ʵ��
    class DefaultSQLParser : public ISQLParser {
    public:
        DefaultSQLParser(const SQLParserConfig& config = SQLParserConfig());
        ~DefaultSQLParser();

        bool parse(const std::string& sql, SQLParserResult* result) override;
        bool tokenize(const std::string& sql, std::vector<int16_t>* tokens) override;

    private:
        std::unique_ptr<SQLParserContext> context_;
        std::unique_ptr<SQLErrorHandler> errorHandler_;
        std::unique_ptr<SQLTokenizer> tokenizer_;
        std::unique_ptr<SQLSyntaxAnalyzer> syntaxAnalyzer_;
    };

    class SQLParser {
    public:
        // ����sql��䣬���ת���ɹ�����true��ʧ�ܷ���false�����������sql�����Ч�������Ч����result->isValid();
        static bool parse(const std::string& sql, SQLParserResult* result);
        // �ִ�Ϊ����
        static bool tokenize(const std::string& sql, std::vector<int16_t>* tokens);

        // �µĹ�������
        static std::unique_ptr<ISQLParser> createParser(const SQLParserConfig& config = SQLParserConfig());
        static void setGlobalConfig(const SQLParserConfig& config);
        static const SQLParserConfig& getGlobalConfig();

    private:
        SQLParser();
        static SQLParserConfig globalConfig_;
        static std::unique_ptr<DefaultSQLParser> defaultInstance_;
    };

} // namespace ment


#endif